package lib.self.utils;

import java.io.File;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;

import lib.self.LogMgr;

/**
 * description: 文件管理
 * author: Steven Xiao
 * date: 2017/4/27
 */
public class FileUtil {
    private static final String TAG = FileUtil.class.getSimpleName();

    private static final int KSizeTypeB = 1;//获取文件大小单位为B的double值
    private static final int KSizeTypeKB = 2;//获取文件大小单位为KB的double值
    private static final int KSizeTypeMB = 3;//获取文件大小单位为MB的double值
    private static final int KSizeTypeGB = 4;//获取文件大小单位为GB的double值

    private static ArrayList<File> mFileList;//获取文件夹下的文件

    /**
     * 通过路径 创建文件夹
     */
    static void ensureFileExist(String filePath) {
        File dirFile = new File(filePath);
        ensureFileExist(dirFile);
    }

    /**
     * 通过File 创建文件夹
     */
    private static void ensureFileExist(File file) {
        if (!file.exists()) {
            file.mkdirs();
        }
    }


    /**
     * 获取文件指定文件的指定单位的大小
     *
     * @param filePath 文件路径
     * @param sizeType 获取大小的类型1为B、2为KB、3为MB、4为GB
     * @return double值的大小
     */
    public static double getFileOrFilesSize(String filePath, int sizeType) {
        File file = new File(filePath);
        if (!file.exists()) {
            return 0;
        }
        long blockSize = 0;
        try {
            if (file.isDirectory()) {
                blockSize = getFileSizes(file);
            } else {
                blockSize = getFileSize(file);
            }
        } catch (Exception e) {
            e.printStackTrace();
            LogMgr.e(TAG, "获取文件大小获取失败!");
        }
        return formatFileSize(blockSize, sizeType);
    }

    /**
     * 调用此方法自动计算指定文件或指定文件夹的大小
     *
     * @param filePath 文件路径
     * @return 计算好的带B、KB、MB、GB的字符串
     */
    public static String getAutoFileOrFilesSize(String filePath) {
        File file = new File(filePath);
        long blockSize = 0;
        try {
            if (file.isDirectory()) {
                blockSize = getFileSizes(file);
            } else {
                blockSize = getFileSize(file);
            }
        } catch (Exception e) {
            e.printStackTrace();
            LogMgr.e(TAG, "获取文件大小获取失败!");
        }
        return formatFileSize(blockSize);
    }

    /**
     * 获取指定文件大小
     *
     * @return
     */
    private static long getFileSize(File file) {
        long size = 0;
        if (file.exists()) {
            size = file.length();
        }
        return size;
    }

    /**
     * 获取指定文件大小
     *
     * @return
     * @throws Exception
     */
    public static long getFileSize(String filePath) {
        try {
            return getFileSize(new File(filePath));
        } catch (Exception e) {
            LogMgr.e(TAG, e);
        }
        return 0;
    }

    /**
     * 获取指定文件夹
     *
     * @param f
     * @return
     * @throws Exception
     */
    private static long getFileSizes(File f) {
        long size = 0;
        File[] listFiles = f.listFiles();
        for (File listFile : listFiles) {
            if (listFile.isDirectory()) {
                size = size + getFileSizes(listFile);
            } else {
                size = size + getFileSize(listFile);
            }
        }
        return size;
    }

    /**
     * 转换文件大小
     *
     * @param size
     * @return
     */
    public static String formatFileSize(long size) {
        DecimalFormat df = new DecimalFormat("#.00");
        String transSize;
        String wrongSize = "0B";
        if (size == 0) {
            return wrongSize;
        }
        if (size < 1024) {
            transSize = df.format((double) size) + "B";
        } else if (size < 1048576) {
            transSize = df.format((double) size / 1024) + "KB";
        } else if (size < 1073741824) {
            transSize = df.format((double) size / 1048576) + "MB";
        } else {
            transSize = df.format((double) size / 1073741824) + "GB";
        }
        return transSize;
    }

    /**
     * 转换文件大小,指定转换的类型
     *
     * @param fileS
     * @param sizeType
     * @return
     */
    private static double formatFileSize(long fileS, int sizeType) {
        DecimalFormat df = new DecimalFormat("#.00");
        double fileSizeLong = 0;
        switch (sizeType) {
            case KSizeTypeB:
                fileSizeLong = Double.valueOf(df.format((double) fileS));
                break;
            case KSizeTypeKB:
                fileSizeLong = Double.valueOf(df.format((double) fileS / 1024));
                break;
            case KSizeTypeMB:
                fileSizeLong = Double.valueOf(df.format((double) fileS / 1048576));
                break;
            case KSizeTypeGB:
                fileSizeLong = Double.valueOf(df.format((double) fileS / 1073741824));
                break;
            default:
                break;
        }
        return fileSizeLong;
    }

    /**
     * 删除文件夹下所有内容包括文件夹本身
     */
    public static void delFolder(String folderPath) {
        try {
            delAllFile(folderPath); // 删除完里面所有内容
            File myFilePath = new File(folderPath);
            myFilePath.delete(); // 删除空文件夹
        } catch (Exception e) {
            LogMgr.e(TAG, e.toString());
        }
    }


    /**
     * 保留空文件夹, 只删除文件夹下的内容
     *
     * @param folderPath
     */
    public static void delOnlyFolderContained(String folderPath) {
        try {
            delAllFile(folderPath); // 删除完里面所有内容
        } catch (Exception e) {
            LogMgr.e(TAG, e);
        }
    }

    private static void delAllFile(String path) {
        File file = new File(path);
        if (!file.exists()) {
            return;
        }
        if (!file.isDirectory()) {
            return;
        }
        String[] tempList = file.list();
        File temp;
        for (String s : tempList) {
            if (path.endsWith(File.separator)) {
                temp = new File(path + s);
            } else {
                temp = new File(path + File.separator + s);
            }
            if (temp.isFile()) {
                temp.delete();
            }
            if (temp.isDirectory()) {
                delAllFile(path + File.separator + s);// 先删除文件夹里面的文件
                delFolder(path + File.separator + s);// 再删除空文件夹
            }
        }
    }

    public static List<File> getFileList(String foldPath) {
        mFileList = new ArrayList<>();
        File dir = new File(foldPath);
        if (!dir.exists()) {
            LogMgr.e(TAG, "文件夹不存在");
        } else {
            File[] files = dir.listFiles(); // 该文件目录下文件全部放入数组
            if (files != null) {
                for (File file : files) {
                    String absolutePath = file.getAbsolutePath();
                    String name = file.getName();
                    if (name.startsWith(".")) {
                        continue;
                    }
                    if (file.isDirectory()) { // 判断是文件还是文件夹
                        processChild(absolutePath); // 获取文件绝对路径
                    } else {
                        LogMgr.e(TAG, absolutePath);
                        if (!name.startsWith(".")) {
                            mFileList.add(file);
                        }
                    }
                }
            }
        }
        return mFileList;
    }

    /**
     * 获取子文件夹里的文件
     */
    private static void processChild(String foldPath) {
        File dir = new File(foldPath);
        File[] files = dir.listFiles();
        if (files != null) {
            for (File file : files) {
                if (file.isDirectory()) {
                    processChild(file.getAbsolutePath());
                } else {
                    String strFileName = file.getAbsolutePath();
                    LogMgr.e(TAG, strFileName);
                    if (!strFileName.startsWith(".")) {
                        mFileList.add(file);
                    }
                }
            }
        }
    }
}
